package p.ithorns.tools.translator.annotation;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;


/**
 * 字典接口
 * <p>
 * 自定义的字典枚举类实现本接口后可省略属性code和text，以及对应的get方法
 * 在构造方法中只需调用init方法即可初始化
 *
 * 优化字段获取方式
 *
 * @author Ht.L
 * @date 2021-12
 */
public interface IDict<T> {

    /**
     * 获取编码
     *
     * @return 编码
     */
    T getCode();

    /**
     * 获取文本
     *
     * @return 文本
     */
    String getText();

    /**
     * 初始化
     *
     * @param code 字典编码
     * @param text 字典文本
     */
    default void init(T code, String text) {
        DictPool.putDict(this, code, text);
    }

    /**
     * 通过code获取字典枚举实例
     *
     * @param clazz 枚举class
     * @param code  code
     * @param <T>   字典code类型
     * @param <R>   枚举类型
     * @return 字典枚举实例
     */
    @SuppressWarnings("unchecked")
    static <T, R extends IDict<T>> R getByCode(Class<? extends IDict<T>> clazz, T code) {
        return (R) DictPool.getByCode(clazz, code);
    }

    /**
     * 通过code获取value
     *
     * @param clazz 枚举class
     * @param code  code
     * @return text
     */
    static <T> String getTextByCode(Class<? extends IDict<T>> clazz, T code) {
        return DictPool.getTextByCode(clazz, code);
    }

    /**
     * 通过text获取code
     *
     * @param clazz 枚举class
     * @param text  text
     * @return code
     */
    static <T> T getCodeByText(Class<? extends IDict<T>> clazz, String text) {
        List<? extends IDict<?>> dict = DictPool.getDict(clazz);
        Object o = dict.stream()
                .filter(e -> e.getText().equals(text))
                .map(IDict::getCode)
                .findAny().orElse(null);
        return (T) o;
    }


    @SuppressWarnings("all")
    class DictPool {
        private static final Map<Class<? extends IDict>, Set<Object>> KEY_SET_MAP = new ConcurrentHashMap<>();

        private static final Map<Object, IDict<?>> DICT_MAP = new ConcurrentHashMap<>();

        static <T> void putDict(IDict<T> dict, T code, String text) {
            Class<? extends IDict> clazz = dict.getClass();
            Object key = getKey(clazz, code);
            KEY_SET_MAP.computeIfAbsent(clazz, k -> new HashSet<>()).add(key);
            DICT_MAP.put(key, dict);
        }

        /**
         * 获取所有字典枚举项（常用下拉框数据请求）
         * 枚举值上标记@Deprecated的不会返回
         *
         * @param clazz 字典枚举类
         * @return List
         */
        public static List<? extends IDict<?>> getDict(Class<? extends IDict> clazz) {
            checkAndInit(clazz);
            Set<Object> keySet = KEY_SET_MAP.get(clazz);
            return keySet.stream()
                    .map(key -> DICT_MAP.get(key))
                    .filter(e -> !e.getClass().isAnnotationPresent(Deprecated.class))
                    .collect(Collectors.toList());
        }

        static <K extends IDict<T>, T> BaseDict<T> getDict(K dict) {
            return new BaseDict<>(dict.getCode(), dict.getText());
        }

        static <T> IDict<?> getByCode(Class<? extends IDict<T>> clazz, T code) {
            checkAndInit(clazz);
            Object key = getKey(clazz, code);
            return DICT_MAP.get(key);
        }

        static <T> String getTextByCode(Class<? extends IDict<T>> clazz, T code) {
            checkAndInit(clazz);
            Object key = getKey(clazz, code);
            return Optional.ofNullable(DICT_MAP.get(key))
                    .map(IDict::getText)
                    .orElse("");
        }

        static void checkAndInit(Class<? extends IDict> clazz) {
            if (!KEY_SET_MAP.containsKey(clazz)) {
                IDict[] enumConstants = clazz.getEnumConstants();
                for (IDict enumConstant : enumConstants) {
                    enumConstant.init(enumConstant.getCode(), enumConstant.getText());
                    System.out.println("init: " + enumConstant);
                }
            }
        }

        static Object getKey(Class<? extends IDict> clazz, Object code) {
            return clazz.getName() + "#" + code;
        }
    }

}